// /**
//  * 绘制三维圆柱区域，并对圆心进行标注和添加圆点
//  * @param {Object} viewer - Cesium Viewer 对象，用于在场景中添加实体。
//  * @param {Number} lon - 圆心的经度。
//  * @param {Number} lat - 圆心的纬度。
//  * @param {Number} minHeight - 圆柱的底部高度。
//  * @param {Number} maxHeight - 圆柱的顶部高度。
//  * @param {Number} radius - 圆柱的半径。
//  * @param {String} color - 圆柱的颜色。
//  * @param {Number} alpha - 圆柱的透明度。
//  * @returns {Object} - 返回绘制的实体。
//  */
export function drawCylinderAreaM1(viewer, lon, lat, minHeight, maxHeight, radius, color, alpha = 0.5, text = "起降场") {
  const height = maxHeight - minHeight; // 计算圆柱的高度

  const entity = viewer.entities.add({
    id: `cylinder-${text}`, // 唯一标识（前缀+名称，避免与其他实体冲突）
    name: text, // 核心：与tableData中的name对应，点击时用于匹配数据

    position: Cesium.Cartesian3.fromDegrees(lon, lat, minHeight + height / 2), // 圆柱体中心位置
    cylinder: {
      length: height,
      topRadius: radius,
      bottomRadius: radius,
      material: Cesium.Color[color.toUpperCase()].withAlpha(alpha),
      outline: true, // 是否显示轮廓
      outlineColor: Cesium.Color[color.toUpperCase()], // 轮廓颜色
      outlineWidth: 1 // 轮廓线宽
    },
  });

  viewer.entities.add({
    position: Cesium.Cartesian3.fromDegrees(lon, lat, maxHeight + 10), // 圆柱体中心位置
    label: {
      text: text, // 根据需要替换为对应的标签内容
      font: '20px sans-serif',
      fillColor: Cesium.Color.WHITE,
      style: Cesium.LabelStyle.FILL_AND_OUTLINE,
      outlineWidth: 2,
      outlineColor: Cesium.Color.BLACK,
      verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
      heightReference: Cesium.HeightReference.NONE,
      scaleByDistance: new Cesium.NearFarScalar(1.5e2, 1.5, 1.0e7, 0.5),
      disableDepthTestDistance: Number.POSITIVE_INFINITY,
      // distanceDisplayCondition: new Cesium.DistanceDisplayCondition(0.0, 4000.0) // 可见距离为 0 到 3000 米
      // 获取相机的俯仰角度（pitch）
      distanceDisplayCondition: (function () {
        const camera = viewer.camera;
        const pitch = camera.pitch; // 俯仰角度

        // 使用指数衰减函数来调整可视距离
        const scale = Math.exp(-Math.abs(pitch) * 1 / Math.PI); // 增加指数衰减的强度
        const visibleDistance = 4000.0 * scale; // 最大可见距离4000，按比例缩小

        return new Cesium.DistanceDisplayCondition(0.0, visibleDistance); // 返回更新后的可见距离
      })()
    }
  });

  return entity; // 返回绘制的实体
}

// /**
//  * 绘制多个固定的三维圆柱体区域，并对圆心进行标注和添加圆点
//  * @param {Object} viewer - Cesium Viewer 对象，用于在场景中添加实体。
//  * @param {Number} lon - 圆心的经度。
//  * @param {Number} lat - 圆心的纬度。
//  * @param {Number} minHeight - 圆柱的底部高度。
//  * @param {Number} maxHeight - 圆柱的顶部高度。
//  * @param {Number} radius - 圆柱的半径。
//  * @param {String} color - 圆柱的颜色。
//  * @param {Number} alpha - 圆柱的透明度（可选，默认值为 0.5）。
//  * @param {String} text - 标签文字（可选，默认值为 "起降场"）。
//  * @returns {Array} - 返回绘制的实体数组。
//  */
// export function drawMultipleFixedCylinders(viewer, lon, lat, minHeight, maxHeight, radius, color, alpha = 0.5, text = "起降场") {
//   // export function drawCylinderAreaM1(viewer, lon, lat, minHeight, maxHeight, radius, color, alpha = 0.5, text = "起降场") {
//   const entities = [];

//   // 固定的柱体数据
//   const cylindersData = [
//     { minHeight: 200, maxHeight: 280, radius: 200, color: '#80c0bf', text: text },
//     { minHeight: 0, maxHeight: 200, radius: 100, color: '#7edfde', text: '' },
//     { minHeight: 0, maxHeight: 350, radius: 50, color: '#bee2be', text: '' },
//   ];

//   // 遍历每个柱体数据并绘制
//   cylindersData.forEach((data, index) => {
//     const { minHeight, maxHeight, radius, color, text } = data;
//     const height = maxHeight - minHeight; // 计算圆柱的高度

//     // 使用 Cesium.Color.fromCssColorString 来解析 RGB 或 16进制颜色
//     const materialColor = Cesium.Color.fromCssColorString(color).withAlpha(alpha);

//     // 绘制圆柱体
//     const cylinderEntity = viewer.entities.add({
//       position: Cesium.Cartesian3.fromDegrees(lon, lat, minHeight + height / 2), // 圆柱体中心位置
//       cylinder: {
//         length: height,
//         topRadius: radius,
//         bottomRadius: radius,
//         material: materialColor, // 设置颜色和透明度
//         // outline: true, // 是否显示轮廓
//         // outlineColor: materialColor, // 轮廓颜色
//         // outlineWidth: 1 // 轮廓线宽
//       },
//     });

//     // 在圆柱体顶部添加标签
//     const labelEntity = viewer.entities.add({
//       position: Cesium.Cartesian3.fromDegrees(lon, lat, maxHeight + 10), // 圆柱体顶部位置
//       label: {
//         text: text, // 标签文字
//         font: '20px sans-serif',
//         fillColor: Cesium.Color.WHITE,
//         style: Cesium.LabelStyle.FILL_AND_OUTLINE,
//         outlineWidth: 2,
//         outlineColor: Cesium.Color.BLACK,
//         verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
//         heightReference: Cesium.HeightReference.NONE,
//         scaleByDistance: new Cesium.NearFarScalar(1.5e2, 1.5, 1.0e7, 0.5),
//         disableDepthTestDistance: Number.POSITIVE_INFINITY,
//         distanceDisplayCondition: (function () {
//           const camera = viewer.camera;
//           const pitch = camera.pitch; // 俯仰角度

//           const scale = Math.exp(-Math.abs(pitch) * 1 / Math.PI); // 增加指数衰减的强度
//           const visibleDistance = 4000.0 * scale; // 最大可见距离4000，按比例缩小

//           return new Cesium.DistanceDisplayCondition(0.0, visibleDistance); // 返回更新后的可见距离
//         })()
//       }
//     });

//     // 将圆柱体和标签实体推送到数组中
//     entities.push(cylinderEntity, labelEntity);
//   });

//   return entities; // 返回所有绘制的实体数组
// }
/**
 * 绘制多个固定的三维圆柱体区域，并对圆心进行标注和添加圆点
 * @param {Object} viewer - Cesium Viewer 对象，用于在场景中添加实体。
 * @param {Number} lon - 圆心的经度。
 * @param {Number} lat - 圆心的纬度。
 * @param {Number} minHeight - 圆柱的底部高度。
 * @param {Number} maxHeight - 圆柱的顶部高度。
 * @param {Number} radius - 圆柱的半径。
 * @param {String} color - 圆柱的颜色。
 * @param {Number} alpha - 圆柱的透明度（可选，默认值为 0.5）。
 * @param {String} text - 标签文字（可选，默认值为 "起降场"）。
 * @returns {Array} - 返回绘制的实体数组。
 */
export function drawMultipleFixedCylinders(viewer, lon, lat, minHeight, maxHeight, radius, color, alpha = 0.5, text = "起降场") {
  const entities = [];

  // 固定的柱体数据
  const cylindersData = [
    { minHeight: 200, maxHeight: 280, radius: 200, color: '#80c0bf', text: text },
    { minHeight: 0, maxHeight: 200, radius: 100, color: '#7edfde', text: '' },
    { minHeight: 0, maxHeight: 350, radius: 50, color: '#bee2be', text: '' },
  ];

  // ==============================================
  // ✅ 修改点1：绘制前删除该区域已存在的旧实体（避免ID重复报错）
  // ==============================================
  cylindersData.forEach((_, index) => {
    // 删除旧圆柱（ID格式与后续新增一致）
    const oldCylinderId = `multi-cylinder-${text}-${index}`;
    const oldCylinder = viewer.entities.getById(oldCylinderId);
    if (oldCylinder) viewer.entities.remove(oldCylinder);

    // 删除旧标签（只需要删除第一个柱体的旧标签，因为后两个柱体不创建标签）
    if (index === 0) {
      const oldLabelId = `multi-cylinder-label-${text}`;
      const oldLabel = viewer.entities.getById(oldLabelId);
      if (oldLabel) viewer.entities.remove(oldLabel);
    }
  });

  // 遍历每个柱体数据并绘制
  cylindersData.forEach((data, index) => {
    // ==============================================
    // ✅ 优化：解构时加前缀，避免覆盖外部传入的minHeight/maxHeight等参数
    // ==============================================
    const { minHeight: dataMinH, maxHeight: dataMaxH, radius: dataRadius, color: dataColor, text: dataText } = data;
    const height = dataMaxH - dataMinH; // 计算圆柱的高度

    // 使用 Cesium.Color.fromCssColorString 来解析 RGB 或 16进制颜色
    const materialColor = Cesium.Color.fromCssColorString(dataColor).withAlpha(alpha);

    // ==============================================
    // ✅ 修改点2：给圆柱实体加「唯一ID」和「统一name」
    // ==============================================
    const cylinderEntity = viewer.entities.add({
      id: `multi-cylinder-${text}-${index}`, // 唯一ID：整体标识+索引（避免重复）
      name: text, // 统一name：3个柱体都用外部传入的text（视为一个整体）
      position: Cesium.Cartesian3.fromDegrees(lon, lat, dataMinH + height / 2), // 圆柱体中心位置
      cylinder: {
        length: height,
        topRadius: dataRadius,
        bottomRadius: dataRadius,
        material: materialColor, // 设置颜色和透明度
        // outline: true, // 是否显示轮廓
        // outlineColor: materialColor, // 轮廓颜色
        // outlineWidth: 1 // 轮廓线宽
      },
    });
    entities.push(cylinderEntity);

    // ==============================================
    // ✅ 修改点3：只给有文本的柱体创建标签（避免空标签冗余）
    // ==============================================
    if (dataText) { // 只有第一个柱体的dataText = text（非空），才创建标签
      const labelEntity = viewer.entities.add({
        id: `multi-cylinder-label-${text}`, // 标签唯一ID（与整体绑定）
        position: Cesium.Cartesian3.fromDegrees(lon, lat, dataMaxH + 10), // 圆柱体顶部位置
        label: {
          text: dataText, // 标签文字（即外部传入的text）
          font: '20px sans-serif',
          fillColor: Cesium.Color.WHITE,
          style: Cesium.LabelStyle.FILL_AND_OUTLINE,
          outlineWidth: 2,
          outlineColor: Cesium.Color.BLACK,
          verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
          heightReference: Cesium.HeightReference.NONE,
          scaleByDistance: new Cesium.NearFarScalar(1.5e2, 1.5, 1.0e7, 0.5),
          disableDepthTestDistance: Number.POSITIVE_INFINITY,
          distanceDisplayCondition: (function () {
            const camera = viewer.camera;
            const pitch = camera.pitch; // 俯仰角度

            const scale = Math.exp(-Math.abs(pitch) * 1 / Math.PI); // 增加指数衰减的强度
            const visibleDistance = 4000.0 * scale; // 最大可见距离4000，按比例缩小

            return new Cesium.DistanceDisplayCondition(0.0, visibleDistance); // 返回更新后的可见距离
          })()
        }
      });
      entities.push(labelEntity);
    }
  });

  return entities; // 返回所有绘制的实体数组
}





/**
 * 绘制三维轨迹长方体走廊边框（航路模式），并添加点标注
 * @param {Object} viewer - Cesium Viewer 对象，用于在场景中添加实体。
 * @param {Array} positions - 包含每个点的经纬度和高度 [lon1, lat1, alt1, lon2, lat2, alt2, ...]。
 * @param {Array} sizes - 每段的长宽高数组 [[width1, height1], [width2, height2], ...]。
 * @param {Number} alpha - 透明度
 * @param {String} color - 管道的颜色。
 * @param {String} text - 中间点标注文本。
 * @param {Array} pointNames - 每个点的名称，用于标注。
 * @param {String} cornerType - 管道拐角处的类型（默认使用圆角）。
 * @returns {Array} - 返回所有绘制的实体数组。
 */
export function draw3DRectangularPipelineTrackM1_2(viewer, positions, sizes, alpha, color = 'YELLOW', text = '航线标签', pointNames = [], cornerType = Cesium.CornerType.ROUNDED) {
  // 流动材质Cesium.PolylineTrailMaterialProperty
  // // 发光效果
  const cartesianPositions = [];
  let minHeight = Infinity;
  let maxHeight = -Infinity;

  // 转换坐标点并计算整体的最小和最大高度
  for (let i = 0; i < positions.length; i += 3) {
    const lon = positions[i];
    const lat = positions[i + 1];
    const alt = positions[i + 2];
    const position = Cesium.Cartesian3.fromDegrees(lon, lat, alt);
    cartesianPositions.push(position);
    maxHeight = Math.max(maxHeight, alt);
  }

  minHeight = maxHeight - sizes[0][1];

  const overallWidth = Math.max(...sizes.map(size => size[0]));
  const overallHeight = maxHeight - minHeight;

  // 使用发光效果材质
  const glowingMaterial = new Cesium.PolylineGlowMaterialProperty({
    glowPower: 0.1,  // 控制光辉的强度
    // color: Cesium.Color[color.toUpperCase()].withAlpha(alpha)  // 设置光辉的颜色和透明度
    color: Cesium.Color[color.toUpperCase()].withAlpha(0.2)  // 设置光辉的颜色和透明度
  });
  // 计算中心点（取中间两个点平均）
  const middleIndex = Math.floor((cartesianPositions.length - 1) / 2);
  const midPoint = Cesium.Cartesian3.add(
    cartesianPositions[middleIndex],
    cartesianPositions[middleIndex + 1],
    new Cesium.Cartesian3()
  );
  Cesium.Cartesian3.multiplyByScalar(midPoint, 0.5, midPoint);
  // 创建走廊边框
  const corridorEntity = viewer.entities.add({
    name: text,
    position: midPoint, // ✅ 添加 position 让 InfoBox 知道实体位置
    corridor: {
      positions: cartesianPositions,
      width: overallWidth,
      height: minHeight,
      extrudedHeight: maxHeight,
      material: glowingMaterial,  // 使用发光材质
      cornerType: cornerType,
      outline: true,
      outlineColor: Cesium.Color[color.toUpperCase()],
      outlineWidth: 1,
    },
  });
  // ✅ 👇 立刻加上自动飞过去的代码
  viewer.flyTo(corridorEntity, { duration: 1.5 });
  // // 💬 插入：浮动 HTML 弹窗
  // const tooltipDiv = document.createElement('div');
  // tooltipDiv.className = 'floating-tooltip';
  // tooltipDiv.innerHTML = `
  //   <div>
  //     名称：${text}<br/>
  //     高度：${minHeight} - ${maxHeight} 米<br/>
  //     宽度：${overallWidth} 米
  //   </div>
  // `;
  // // ✅ 所有样式都集中写在这里
  // Object.assign(tooltipDiv.style, {
  //   position: 'absolute',
  //   padding: '12px 16px',
  //   // backgroundImage: 'url("/path/to/bg.png")', // ✅ 替换为你自己的背景图路径
  //   backgroundSize: 'cover',
  //   backgroundPosition: 'center',
  //   backgroundColor: 'rgba(0, 0, 0, 0.5)', // 可选兜底色
  //   color: 'white',
  //   fontSize: '14px',
  //   borderRadius: '8px',
  //   opacity: '0.9',
  //   pointerEvents: 'none',
  //   whiteSpace: 'nowrap',
  //   transform: 'translate(-50%, -100%)',
  //   zIndex: '9999',
  //   boxShadow: '0 4px 12px rgba(0,0,0,0.4)',
  //   display: 'none', // 默认隐藏，靠近时显示
  // });


  // document.body.appendChild(tooltipDiv);

  // function updateTooltipPosition() {
  //   const position = corridorEntity.position?.getValue(viewer.clock.currentTime);
  //   if (!position) return;

  //   const offset = new Cesium.Cartesian3(0, 0, 200);
  //   const elevatedPos = Cesium.Cartesian3.add(position, offset, new Cesium.Cartesian3());

  //   const canvasPosition = viewer.scene.cartesianToCanvasCoordinates(elevatedPos, new Cesium.Cartesian2());
  //   if (!canvasPosition) {
  //     tooltipDiv.style.display = 'none';
  //     return;
  //   }

  //   // ✅ 计算相机和实体之间的距离
  //   const cameraPos = viewer.camera.positionWC;
  //   const distance = Cesium.Cartesian3.distance(cameraPos, position);

  //   // ✅ 控制距离内才显示
  //   if (distance < 1500) {
  //     tooltipDiv.style.left = `${canvasPosition.x}px`;
  //     tooltipDiv.style.top = `${canvasPosition.y}px`;
  //     tooltipDiv.style.display = 'block';
  //     tooltipDiv.style.position = 'absolute';
  //   } else {
  //     tooltipDiv.style.display = 'none';
  //   }
  // }

  // viewer.scene.postRender.addEventListener(updateTooltipPosition);

  const entities = [corridorEntity];

  // 添加点标注 1201更新后
  if (text) {
    const middleIndex = Math.floor((cartesianPositions.length - 1) / 2);
    const midPoint = Cesium.Cartesian3.add(cartesianPositions[middleIndex], cartesianPositions[middleIndex + 1], new Cesium.Cartesian3());
    Cesium.Cartesian3.multiplyByScalar(midPoint, 0.5, midPoint);

    // 获取相机的俯仰角度
    const camera = viewer.camera;
    const pitch = camera.pitch; // 俯仰角度

    // 使用指数衰减函数根据俯仰角度调整可见距离
    const scale = Math.exp(-Math.abs(pitch) * 1 / Math.PI); // 使用指数衰减，控制缩小程度
    const visibleDistance = 4000.0 * scale; // 最大距离4000，按比例缩小

    // 设置文字的显示距离
    const distanceDisplayCondition = new Cesium.DistanceDisplayCondition(0.0, visibleDistance);

    viewer.entities.add({
      position: Cesium.Cartesian3.add(midPoint, new Cesium.Cartesian3(0, 0, overallHeight / 2), new Cesium.Cartesian3()),
      label: {
        text: text,
        font: '20px sans-serif',
        fillColor: Cesium.Color.WHITE,
        style: Cesium.LabelStyle.FILL_AND_OUTLINE,
        outlineWidth: 2,
        outlineColor: Cesium.Color.BLACK,
        verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
        heightReference: Cesium.HeightReference.NONE,
        scaleByDistance: new Cesium.NearFarScalar(1.5e2, 1.5, 1.0e7, 0.5),
        disableDepthTestDistance: Number.POSITIVE_INFINITY,
        distanceDisplayCondition: distanceDisplayCondition
      }
    });
  }

  return entities;
}


function getAlertColor(level) {
  switch (level) {
    case 1: return '#4caf50';      // 绿色
    case 2: return '#4caf50';      // 绿色
    case 3: return '#4caf50';      // 绿色
    case 4: return '#ff9800';      // 橙色
    case 5: return '#f44336';      // 红色
    default: return '#999';        // 默认灰
  }
}

function getAlertLevel(level) {
  const levels = {
    1: '安全',
    2: '安全',
    3: '安全',
    4: '预警',
    5: '告警',
  };
  return levels[level] || '未知';
}


/**
 * 绘制三维轨迹长方体走廊边框（航线模式绘制航线-不显示弹窗，显示整体名称），并添加点标注
 * @param {Object} viewer - Cesium Viewer 对象，用于在场景中添加实体。
 * @param {Array} positions - 包含每个点的经纬度和高度 [lon1, lat1, alt1, lon2, lat2, alt2, ...]。
 * @param {Array} sizes - 每段的长宽高数组 [[width1, height1], [width2, height2], ...]。
 * @param {Number} alpha - 透明度
 * @param {String} color - 管道的颜色。
 * @param {String} text - 中间点标注文本。
 * @param {Array} pointNames - 每个点的名称，用于标注。
 * @param {String} cornerType - 管道拐角处的类型（默认使用圆角）。
 * @returns {Array} - 返回所有绘制的实体数组。
 */
export function draw3DRectangularPipelineTrackM1_3(viewer, positions, sizes, alpha, color = 'YELLOW', text = '航线标签', pointNames = [], cornerType = Cesium.CornerType.ROUNDED, alertLevel,
  alertFlow) {
  // 流动材质Cesium.PolylineTrailMaterialProperty
  // // 发光效果
  const cartesianPositions = [];
  let minHeight = Infinity;
  let maxHeight = -Infinity;

  // 转换坐标点并计算整体的最小和最大高度
  for (let i = 0; i < positions.length; i += 3) {
    const lon = positions[i];
    const lat = positions[i + 1];
    const alt = positions[i + 2];
    const position = Cesium.Cartesian3.fromDegrees(lon, lat, alt);
    cartesianPositions.push(position);
    maxHeight = Math.max(maxHeight, alt);
  }

  minHeight = maxHeight - sizes[0][1];

  const overallWidth = Math.max(...sizes.map(size => size[0]));
  const overallHeight = maxHeight - minHeight;

  // 使用发光效果材质
  const glowingMaterial = new Cesium.PolylineGlowMaterialProperty({
    glowPower: 0.1,  // 控制光辉的强度
    // color: Cesium.Color[color.toUpperCase()].withAlpha(alpha)  // 设置光辉的颜色和透明度
    color: Cesium.Color[color.toUpperCase()].withAlpha(0.2)  // 设置光辉的颜色和透明度
  });
  // 计算中心点（取中间两个点平均）
  const middleIndex = Math.floor((cartesianPositions.length - 1) / 2);
  const midPoint = Cesium.Cartesian3.add(
    cartesianPositions[middleIndex],
    cartesianPositions[middleIndex + 1],
    new Cesium.Cartesian3()
  );
  Cesium.Cartesian3.multiplyByScalar(midPoint, 0.5, midPoint);
  // 创建走廊边框
  const corridorEntity = viewer.entities.add({
    name: text,
    position: midPoint, // ✅ 添加 position 让 InfoBox 知道实体位置
  });

  // ✅ 中间发光走廊（Glow Corridor）
  const midHeight = minHeight + (overallHeight / 2); // 中间高度
  const glowCorridor = viewer.entities.add({
    // name: `${text}_glow`,
    name: text, // ✅ 跟 row.name 对应
    position: midPoint,
    corridor: {
      positions: cartesianPositions,
      width: overallWidth * 0.8, // 发光线稍细一点
      height: midHeight,
      material: new Cesium.PolylineGlowMaterialProperty({
        glowPower: 0.1,
        color: Cesium.Color[color.toUpperCase()].withAlpha(0.8),
      }),
      cornerType: cornerType,
    },
  });

  // ✅ 👇 立刻加上自动飞过去的代码
  // viewer.flyTo(corridorEntity, { duration: 1.5 });
  viewer.flyTo(glowCorridor, { duration: 1.5 });


  // 浮动 HTML 弹窗
  // const tooltipDiv = document.createElement('div');
  // tooltipDiv.className = 'floating-tooltip';
  // tooltipDiv.innerHTML = `
  //   <div style="display: flex; flex-direction: column; gap: 8px;">
  //     <div style="position:absolute;top:4px;right:8px;cursor:pointer;font-weight:bold;" id="tooltipCloseBtn"></div>
  //     <div>
  //       名称：${text}<br/>
  //       高度：${minHeight} - ${maxHeight} 米<br/>
  //       宽度：${overallWidth} 米
  //     </div>
  //     <div style="display: flex; align-items: center;">
  //       <span>告警等级：</span>
  //       <span style="padding: 2px 10px; border-radius: 12px; font-weight: bold; background-color: ${getAlertColor(alertLevel)}; color: white;">
  //         ${getAlertLevel(alertLevel)}
  //       </span>
  //     </div>
  //     <div style="display: flex; align-items: center;">
  //       <span>当前流量：</span>
  //       <span style="font-weight: bold; color: #ffd700;">${alertFlow} 架次/小时</span>
  //     </div>
  //   </div>
  // `;

  // Object.assign(tooltipDiv.style, {
  //   position: 'absolute',
  //   padding: '12px 16px',
  //   // backgroundImage: 'url("/path/to/bg.png")', // ✅ 替换为你自己的背景图路径
  //   backgroundSize: 'cover',
  //   backgroundPosition: 'center',
  //   backgroundColor: 'rgba(0, 0, 0, 0.5)', // 可选兜底色
  //   color: 'white',
  //   fontSize: '14px',
  //   borderRadius: '8px',
  //   opacity: '0.9',
  //   // pointerEvents: 'none',
  //   pointerEvents: 'auto',
  //   whiteSpace: 'nowrap',
  //   transform: 'translate(-50%, -100%)',
  //   zIndex: '9999',
  //   boxShadow: '0 4px 12px rgba(0,0,0,0.4)',
  //   display: 'none', // 默认隐藏，靠近时显示
  // });


  // document.body.appendChild(tooltipDiv);

  // let removeListener = null;
  // let isTooltipActive = false;
  // let tooltipForceHidden = false;   // ⭐⭐新增：强制关闭开关⭐⭐

  // function closeTooltip() {
  //   tooltipForceHidden = true;      // ⭐⭐关闭按钮关闭后，不允许postRender再次显示⭐⭐
  //   tooltipDiv.style.display = 'none';
  //   if (removeListener) {
  //     viewer.scene.postRender.removeEventListener(removeListener);
  //     removeListener = null;
  //   }
  //   isTooltipActive = false;
  // }

  // function updateTooltipPosition() {
  //   if (tooltipForceHidden) return;   // ⭐⭐增加判断，彻底阻止postRender干扰⭐⭐
  //   const pos = glowCorridor.position.getValue(viewer.clock.currentTime);
  //   if (!pos) return;
  //   const offset = new Cesium.Cartesian3(0, 0, 200);
  //   const elevatedPos = Cesium.Cartesian3.add(pos, offset, new Cesium.Cartesian3());
  //   const canvasPosition = viewer.scene.cartesianToCanvasCoordinates(elevatedPos, new Cesium.Cartesian2());
  //   if (!canvasPosition) return;
  //   tooltipDiv.style.left = `${canvasPosition.x}px`;
  //   tooltipDiv.style.top = `${canvasPosition.y}px`;
  //   tooltipDiv.style.display = 'block';
  // }

  // const handler = new Cesium.ScreenSpaceEventHandler(viewer.scene.canvas);
  // handler.setInputAction(click => {
  //   const picked = viewer.scene.pick(click.position);
  //   if (Cesium.defined(picked) && picked.id === glowCorridor) {
  //     if (isTooltipActive) return;
  //     closeTooltip();
  //     tooltipForceHidden = false;    // ⭐⭐点击corridor后恢复允许显示⭐⭐
  //     updateTooltipPosition();
  //     removeListener = viewer.scene.postRender.addEventListener(updateTooltipPosition);
  //     isTooltipActive = true;
  //   } else {
  //     closeTooltip();
  //   }
  // }, Cesium.ScreenSpaceEventType.LEFT_CLICK);

  // setTimeout(() => {
  //   document.getElementById('tooltipCloseBtn')?.addEventListener('click', closeTooltip);
  // }, 0);

  const entities = [glowCorridor]; // 带 name 且会 flyTo 的实体


  // 根据距离是否显示名称
  if (text) {
    const middleIndex = Math.floor((cartesianPositions.length - 1) / 2);
    const midPoint = Cesium.Cartesian3.add(cartesianPositions[middleIndex], cartesianPositions[middleIndex + 1], new Cesium.Cartesian3());
    Cesium.Cartesian3.multiplyByScalar(midPoint, 0.5, midPoint);

    // 获取相机的俯仰角度
    const camera = viewer.camera;
    const pitch = camera.pitch; // 俯仰角度

    // 使用指数衰减函数根据俯仰角度调整可见距离
    const scale = Math.exp(-Math.abs(pitch) * 1 / Math.PI); // 使用指数衰减，控制缩小程度
    const visibleDistance = 4000.0 * scale; // 最大距离4000，按比例缩小

    // 设置文字的显示距离
    const distanceDisplayCondition = new Cesium.DistanceDisplayCondition(0.0, visibleDistance);

    viewer.entities.add({
      position: Cesium.Cartesian3.add(midPoint, new Cesium.Cartesian3(0, 0, overallHeight / 2), new Cesium.Cartesian3()),
      label: {
        text: text,
        font: '20px sans-serif',
        fillColor: Cesium.Color.WHITE,
        style: Cesium.LabelStyle.FILL_AND_OUTLINE,
        outlineWidth: 2,
        outlineColor: Cesium.Color.BLACK,
        verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
        heightReference: Cesium.HeightReference.NONE,
        scaleByDistance: new Cesium.NearFarScalar(1.5e2, 1.5, 1.0e7, 0.5),
        disableDepthTestDistance: Number.POSITIVE_INFINITY,
        distanceDisplayCondition: distanceDisplayCondition
      }
    });
  }


  return entities;
}

/**
 * 绘制三维轨迹长方体走廊边框（航线模式绘制航路-显示弹窗，不显示整体名称），并添加点标注
 * @param {Object} viewer - Cesium Viewer 对象，用于在场景中添加实体。
 * @param {Array} positions - 包含每个点的经纬度和高度 [lon1, lat1, alt1, lon2, lat2, alt2, ...]。
 * @param {Array} sizes - 每段的长宽高数组 [[width1, height1], [width2, height2], ...]。
 * @param {Number} alpha - 透明度
 * @param {String} color - 管道的颜色。
 * @param {String} text - 中间点标注文本。
 * @param {Array} pointNames - 每个点的名称，用于标注。
 * @param {String} cornerType - 管道拐角处的类型（默认使用圆角）。
 * @returns {Array} - 返回所有绘制的实体数组。
 */
export function draw3DRectangularPipelineTrackM1_4(viewer, positions, sizes, alpha, color = 'YELLOW', text = '航线标签', pointNames = [], cornerType = Cesium.CornerType.ROUNDED, alertLevel,
  alertFlow) {
  // 流动材质Cesium.PolylineTrailMaterialProperty
  // // 发光效果
  const cartesianPositions = [];
  let minHeight = Infinity;
  let maxHeight = -Infinity;

  // 转换坐标点并计算整体的最小和最大高度
  for (let i = 0; i < positions.length; i += 3) {
    const lon = positions[i];
    const lat = positions[i + 1];
    const alt = positions[i + 2];
    const position = Cesium.Cartesian3.fromDegrees(lon, lat, alt);
    cartesianPositions.push(position);
    maxHeight = Math.max(maxHeight, alt);
  }

  minHeight = maxHeight - sizes[0][1];

  const overallWidth = Math.max(...sizes.map(size => size[0]));
  const overallHeight = maxHeight - minHeight;

  // 主颜色统一
  const mainColor = Cesium.Color[color.toUpperCase()].withAlpha(1);

  // 材质
  const glowingMaterial = new Cesium.PolylineGlowMaterialProperty({
    glowPower: 1,
    color: mainColor
  });

  // ⭐⭐ 根据 alertLevel 动态设置宽度
  let corridorWidthFactor = 1.0;     // 默认
  if (alertLevel === 1) corridorWidthFactor = 0.8;
  else if (alertLevel === 2) corridorWidthFactor = 0.8;
  else if (alertLevel === 3) corridorWidthFactor = 0.8;
  else if (alertLevel === 4) corridorWidthFactor = 1.0;
  else if (alertLevel === 5) corridorWidthFactor = 1.0;

  // 计算中心点（取中间两个点平均）
  const middleIndex = Math.floor((cartesianPositions.length - 1) / 2);
  const midPoint = Cesium.Cartesian3.add(
    cartesianPositions[middleIndex],
    cartesianPositions[middleIndex + 1],
    new Cesium.Cartesian3()
  );
  Cesium.Cartesian3.multiplyByScalar(midPoint, 0.5, midPoint);

  // ✅ corridor 用 extrudedHeight 创建立体走廊（样式清爽）
  const corridorEntity = viewer.entities.add({
    name: text,
    position: midPoint,
    corridor: {
      positions: cartesianPositions,
      width: overallWidth * corridorWidthFactor,
      height: minHeight,
      extrudedHeight: maxHeight,
      material: Cesium.Color[color.toUpperCase()].withAlpha(0.6), // 不发光
      cornerType: cornerType
    }
  });

  viewer.flyTo(corridorEntity, { duration: 1.5 });

  // ✅ 中间发光走廊（Glow Corridor）
  const midHeight = minHeight + (overallHeight / 2); // 中间高度
  const glowCorridor = viewer.entities.add({
    // name: `${text}_glow`,
    name: text, // ✅ 跟 row.name 对应
    position: midPoint,
    corridor: {
      positions: cartesianPositions,
      width: overallWidth * 0.00001, // 发光线粗细调整
      height: midHeight,
      material: new Cesium.PolylineGlowMaterialProperty({
        glowPower: 0.3,
        color: Cesium.Color[color.toUpperCase()].withAlpha(0.8),
      }),
      cornerType: cornerType,
    },
  });

  // ✅ 👇 立刻加上自动飞过去的代码
  // viewer.flyTo(corridorEntity, { duration: 1.5 });
  viewer.flyTo(glowCorridor, { duration: 1.5 });


  // 💬 插入：浮动 HTML 弹窗
  const tooltipDiv = document.createElement('div');
  tooltipDiv.className = 'floating-tooltip';
  tooltipDiv.innerHTML = `
    <div style="display: flex; flex-direction: column; gap: 8px;">
      <div style="position:absolute;top:4px;right:8px;cursor:pointer;font-weight:bold;" id="tooltipCloseBtn"></div>
      <div>
        名称：${text}<br/>
        高度：${minHeight} - ${maxHeight} 米<br/>
        宽度：${overallWidth} 米
      </div>
      <div style="display: flex; align-items: center;">
        <span>告警等级：</span>
        <span style="padding: 2px 10px; border-radius: 12px; font-weight: bold; background-color: ${getAlertColor(alertLevel)}; color: white;">
          ${getAlertLevel(alertLevel)}
        </span>
      </div>
      <div style="display: flex; align-items: center;">
        <span>当前流量：</span>
        <span style="font-weight: bold; color: #ffd700;">${alertFlow} 架次/小时</span>
      </div>
    </div>
  `;

  // ✅ 所有样式都集中写在这里
  Object.assign(tooltipDiv.style, {
    position: 'absolute',
    padding: '12px 16px',
    // backgroundImage: 'url("/path/to/bg.png")', // ✅ 替换为你自己的背景图路径
    backgroundSize: 'cover',
    backgroundPosition: 'center',
    backgroundColor: 'rgba(0, 0, 0, 0.5)', // 可选兜底色
    color: 'white',
    fontSize: '14px',
    borderRadius: '8px',
    opacity: '0.9',
    // pointerEvents: 'none',
    pointerEvents: 'auto',
    whiteSpace: 'nowrap',
    transform: 'translate(-50%, -100%)',
    zIndex: '9000',
    boxShadow: '0 4px 12px rgba(0,0,0,0.4)',
    display: 'none', // 默认隐藏，靠近时显示
  });


  document.body.appendChild(tooltipDiv);

  let removeListener = null;
  let isTooltipActive = false;
  let tooltipForceHidden = false;   // ⭐⭐新增：强制关闭开关⭐⭐

  function closeTooltip() {
    tooltipForceHidden = true;      // ⭐⭐关闭按钮关闭后，不允许postRender再次显示⭐⭐
    tooltipDiv.style.display = 'none';
    if (removeListener) {
      viewer.scene.postRender.removeEventListener(removeListener);
      removeListener = null;
    }
    isTooltipActive = false;
  }

  function updateTooltipPosition() {
    if (tooltipForceHidden) return;   // ⭐⭐增加判断，彻底阻止postRender干扰⭐⭐
    const pos = corridorEntity.position.getValue(viewer.clock.currentTime);
    if (!pos) return;
    const offset = new Cesium.Cartesian3(0, 0, 0);
    const elevatedPos = Cesium.Cartesian3.add(pos, offset, new Cesium.Cartesian3());
    const canvasPosition = viewer.scene.cartesianToCanvasCoordinates(elevatedPos, new Cesium.Cartesian2());
    if (!canvasPosition) return;
    tooltipDiv.style.left = `${canvasPosition.x}px`;
    tooltipDiv.style.top = `${canvasPosition.y}px`;
    tooltipDiv.style.display = 'block';
  }

  const handler = new Cesium.ScreenSpaceEventHandler(viewer.scene.canvas);
  handler.setInputAction(click => {
    const picked = viewer.scene.pick(click.position);
    if (Cesium.defined(picked) && picked.id === corridorEntity) {
      if (isTooltipActive) return;
      closeTooltip();
      tooltipForceHidden = false;    // ⭐⭐点击corridor后恢复允许显示⭐⭐
      updateTooltipPosition();
      removeListener = viewer.scene.postRender.addEventListener(updateTooltipPosition);
      isTooltipActive = true;
    } else {
      closeTooltip();
    }
  }, Cesium.ScreenSpaceEventType.LEFT_CLICK);

  setTimeout(() => {
    document.getElementById('tooltipCloseBtn')?.addEventListener('click', closeTooltip);
  }, 0);


  // const entities = [glowCorridor]; // 带 name 且会 flyTo 的实体
  const entities = [corridorEntity];

  // 根据距离是否显示名称
  // if (text) {
  //   const middleIndex = Math.floor((cartesianPositions.length - 1) / 2);
  //   const midPoint = Cesium.Cartesian3.add(cartesianPositions[middleIndex], cartesianPositions[middleIndex + 1], new Cesium.Cartesian3());
  //   Cesium.Cartesian3.multiplyByScalar(midPoint, 0.5, midPoint);

  //   // 获取相机的俯仰角度
  //   const camera = viewer.camera;
  //   const pitch = camera.pitch; // 俯仰角度

  //   // 使用指数衰减函数根据俯仰角度调整可见距离
  //   const scale = Math.exp(-Math.abs(pitch) * 1 / Math.PI); // 使用指数衰减，控制缩小程度
  //   const visibleDistance = 4000.0 * scale; // 最大距离4000，按比例缩小

  //   // 设置文字的显示距离
  //   const distanceDisplayCondition = new Cesium.DistanceDisplayCondition(0.0, visibleDistance);

  //   viewer.entities.add({
  //     position: Cesium.Cartesian3.add(midPoint, new Cesium.Cartesian3(0, 0, overallHeight / 2), new Cesium.Cartesian3()),
  //     label: {
  //       text: text,
  //       font: '20px sans-serif',
  //       fillColor: Cesium.Color.WHITE,
  //       style: Cesium.LabelStyle.FILL_AND_OUTLINE,
  //       outlineWidth: 2,
  //       outlineColor: Cesium.Color.BLACK,
  //       verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
  //       heightReference: Cesium.HeightReference.NONE,
  //       scaleByDistance: new Cesium.NearFarScalar(1.5e2, 1.5, 1.0e7, 0.5),
  //       disableDepthTestDistance: Number.POSITIVE_INFINITY,
  //       distanceDisplayCondition: distanceDisplayCondition
  //     }
  //   });
  // }


  // return entities;
  return {
    entities,
    destroy: closeTooltip, // ✅ 让 Vue 组件可以关闭 tooltip
  };
}


/**
 * 绘制三维轨迹长方体管道（模拟飞行路径，长宽高可变），并添加球体衔接和点标注
 * @param {Object} viewer - Cesium Viewer 对象，用于在场景中添加实体。
 * @param {Array} positions - 包含每个点的经纬度和高度 [lon1, lat1, alt1, lon2, lat2, alt2, ...]。
 * @param {Array} sizes - 每段的长宽高数组 [[width1, height1], [width2, height2], ...]。
 * @param {String} color - 管道的颜色。
 * @param {Array} pointNames - 每个点的名称，用于标注。
 * @returns {Array} - 返回所有绘制的实体数组。
 */
export function draw3DRectangularPipelineTrackM1(viewer, positions, sizes, color = 'YELLOW', pointNames = []) {
  const cartesianPositions = [];
  for (let i = 0; i < positions.length; i += 3) {
    const position = Cesium.Cartesian3.fromDegrees(positions[i], positions[i + 1], positions[i + 2]);
    cartesianPositions.push(position);
  }

  // 确保 sizes 数组的长度与 cartesianPositions 一致
  if (cartesianPositions.length - 1 !== sizes.length) {
    console.error('Positions length does not match sizes length');
    return null;
  }

  const entities = [];

  // 循环每段轨迹并为每段生成不同的长方体横截面
  for (let i = 0; i < cartesianPositions.length - 1; i++) {
    const start = cartesianPositions[i];
    const end = cartesianPositions[i + 1];
    const width = sizes[i][0]; // 每段的宽度
    const height = sizes[i][1]; // 每段的高度

    // 添加实体，绘制不同宽高的长方体管道
    const entity = viewer.entities.add({
      polylineVolume: {
        positions: [start, end], // 每段的起点和终点
        shape: computeRectangleM1(width, height), // 自定义横截面形状（长方形）
        material: Cesium.Color[color.toUpperCase()].withAlpha(0.8), // 管道颜色
        outline: true, // 是否显示轮廓
        outlineColor: Cesium.Color[color.toUpperCase()], // 轮廓颜色
        outlineWidth: 1 // 轮廓线宽
      }
    });

    // 添加到实体数组
    entities.push(entity);

    // 对当前点进行标注
    if (pointNames[i]) {
      viewer.entities.add({
        position: start,
        label: {
          text: pointNames[i],
          font: '10pt sans-serif',
          fillColor: Cesium.Color.WHITE,
          style: Cesium.LabelStyle.FILL_AND_OUTLINE,
          outlineWidth: 2,
          outlineColor: Cesium.Color.BLACK,
          verticalOrigin: Cesium.VerticalOrigin.BOTTOM, // 标签底部与点对齐
          heightReference: Cesium.HeightReference.NONE, // 高度不受地形影响
          scaleByDistance: new Cesium.NearFarScalar(1.5e2, 1.5, 1.0e7, 0.5), // 根据视角缩放大小
          disableDepthTestDistance: Number.POSITIVE_INFINITY, // 确保标注不被其他对象遮挡
          distanceDisplayCondition: new Cesium.DistanceDisplayCondition(0.0, 4000.0) // 可见距离为 0 到 3000 米
        }
      });
    }

    // 添加球体衔接下一个管道
    if (i < cartesianPositions.length - 2) {
      const nextSize = sizes[i + 1];
      const radius = calculateSphereRadius(width, height, nextSize[0], nextSize[1]);
      const nextStart = cartesianPositions[i + 1];
      addConnectionSphere(viewer, nextStart, radius, color);
    }
  }

  // 标注最后一个点
  const endPointName = pointNames[cartesianPositions.length - 1];
  if (endPointName) {
    viewer.entities.add({
      position: cartesianPositions[cartesianPositions.length - 1],
      label: {
        text: endPointName,
        font: '10pt sans-serif',
        fillColor: Cesium.Color.WHITE,
        style: Cesium.LabelStyle.FILL_AND_OUTLINE,
        outlineWidth: 2,
        outlineColor: Cesium.Color.BLACK,
        verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
        heightReference: Cesium.HeightReference.NONE,
        scaleByDistance: new Cesium.NearFarScalar(1.5e2, 1.5, 1.0e7, 0.5), // 根据视角缩放大小
        disableDepthTestDistance: Number.POSITIVE_INFINITY, // 确保标注不被其他对象遮挡
        distanceDisplayCondition: new Cesium.DistanceDisplayCondition(0.0, 4000.0) // 可见距离为 0 到 3000 米
      }
    });
  }

  // 返回所有实体
  return entities;
}

/**
 * 生成长方体的截面形状
 * @param {Number} width - 横截面的宽度。
 * @param {Number} height - 横截面的高度。
 * @returns {Array} - 组成长方形的 Cartesian2 坐标点数组。
 */
function computeRectangleM1(width, height) {
  return [
    new Cesium.Cartesian2(-width / 2, -height / 2), // 左下角
    new Cesium.Cartesian2(width / 2, -height / 2), // 右下角
    new Cesium.Cartesian2(width / 2, height / 2), // 右上角
    new Cesium.Cartesian2(-width / 2, height / 2), // 左上角
  ];
}

/**
 * 根据前后管道段的宽度和高度计算球体的半径
 * @param {Number} width1 - 当前段管道的宽度。
 * @param {Number} height1 - 当前段管道的高度。
 * @param {Number} width2 - 下一个段管道的宽度。
 * @param {Number} height2 - 下一个段管道的高度。
 * @returns {Number} - 球体的半径。
 */
function calculateSphereRadius(width1, height1, width2, height2) {
  // 使用前后两段管道宽高的平均值作为球体的半径
  return Math.max((width1 + width2) / 2, (height1 + height2) / 2) / 2;
}

/**
 * 添加球体连接来平滑连接两段管道
 * @param {Object} viewer - Cesium Viewer 对象，用于在场景中添加实体。
 * @param {Object} position - 球体的位置。
 * @param {Number} radius - 球体的半径。
 * @param {String} color - 球体的颜色。
 */
function addConnectionSphere(viewer, position, radius, color) {
  viewer.entities.add({
    position: position,
    ellipsoid: {
      radii: new Cesium.Cartesian3(radius, radius, radius),
      material: Cesium.Color[color.toUpperCase()].withAlpha(0.8)
    }
  });
}


/**
 * 绘制三维多边形柱状体，并对每个顶点进行标注
 * @param {Object} viewer - Cesium Viewer 对象，用于在场景中添加实体。
 * @param {Array} positions - 包含每个顶点的经纬度 [lon1, lat1, lon2, lat2, ...]。
 * @param {Number} minHeight - 柱状体的底部高度。
 * @param {Number} maxHeight - 柱状体的顶部高度。
 * @param {String} color - 柱状体的颜色。
 * @param {Number} alpha - 柱状体的透明度（默认值为 0.5）。
 * @param {Array} pointNames - 每个顶点的名称，用于标注。
 * @returns {Object} - 返回绘制的实体。
 */
export function draw3DPolygonalPrismM1(viewer, positions, minHeight, maxHeight, color = 'BLUE', alpha = 0.5, text = '区域标签', pointNames = []) {
  const cartesianPositions = [];
  for (let i = 0; i < positions.length; i += 2) {
    const position = Cesium.Cartesian3.fromDegrees(positions[i], positions[i + 1], minHeight);
    cartesianPositions.push(position);
  }

  const height = maxHeight - minHeight;

  // 添加实体，绘制多边形柱状体
  const entity = viewer.entities.add({
    id: `polygon-${text}`, // 唯一标识，结合text确保唯一性
    name: text, // 与tableData中的name对应，用于点击匹配

    polygon: {
      hierarchy: {
        positions: cartesianPositions
      },
      extrudedHeight: maxHeight,
      height: minHeight,
      material: Cesium.Color[color.toUpperCase()].withAlpha(alpha), // 柱状体颜色
      outline: true, // 是否显示轮廓
      outlineColor: Cesium.Color[color.toUpperCase()], // 轮廓颜色
      outlineWidth: 1 // 轮廓线宽
    }
  });

  // 计算多边形的中心点
  const center = calculatePolygonCenter(cartesianPositions);

  viewer.entities.add({
    position: Cesium.Cartesian3.fromDegrees(center.longitude, center.latitude, maxHeight + 10), // 高度比 maxHeight 高10米，确保标签显眼
    label: {
      text: text, // 标签文本
      font: '20pt sans-serif',
      fillColor: Cesium.Color.WHITE,
      style: Cesium.LabelStyle.FILL_AND_OUTLINE,
      outlineWidth: 2,
      outlineColor: Cesium.Color.BLACK,
      verticalOrigin: Cesium.VerticalOrigin.BOTTOM, // 标签底部与点对齐
      heightReference: Cesium.HeightReference.NONE, // 高度不受地形影响
      // distanceDisplayCondition: new Cesium.DistanceDisplayCondition(0.0, 4000.0) // 可见距离为 0 到 3000 米
      // 获取相机的俯仰角度（pitch）
      distanceDisplayCondition: (function () {
        const camera = viewer.camera;
        const pitch = camera.pitch; // 俯仰角度

        // 使用指数衰减函数来调整可视距离
        const scale = Math.exp(-Math.abs(pitch) * 1 / Math.PI); // 增加指数衰减的强度
        const visibleDistance = 4000.0 * scale; // 最大可见距离4000，按比例缩小

        return new Cesium.DistanceDisplayCondition(0.0, visibleDistance); // 返回更新后的可见距离
      })()
    }
  });

  return entity; // 返回绘制的实体
}

// 计算多边形中心点的函数
function calculatePolygonCenter(positions) {
  let longitudeSum = 0;
  let latitudeSum = 0;
  const count = positions.length;

  for (let i = 0; i < count; i++) {
    const cartesian = positions[i];
    const cartographic = Cesium.Cartographic.fromCartesian(cartesian);
    longitudeSum += Cesium.Math.toDegrees(cartographic.longitude);
    latitudeSum += Cesium.Math.toDegrees(cartographic.latitude);
  }

  return {
    longitude: longitudeSum / count,
    latitude: latitudeSum / count
  };
}